package com.unei.guava.demo.fp.supplier;

import com.google.common.base.Predicate;
import com.google.common.base.Supplier;
import com.google.common.base.Suppliers;
import org.junit.Test;

import java.util.concurrent.TimeUnit;

/**
 *
 * SupplierDemo接口
 * public interface Supplier<T>{
 *     T get();
 * }
 * get方法返回T的是一个实例，每次get调用可以返回相同的实例（单例）也可以每次返回新实例。
 * Supplier接口提供了一个灵活的延迟初始化机制直到get方法被调用。
 *
 * Supplier<T> Suppliers.memoize(Supplier<T> delegate)
 * 对delegate进行包装，对其get调用将返回delegate.get的执行结果，只有第一次调用时delegate.get会被
 * 执行，Supplier<T>会缓存delegate.get的结果，后面的调用将返回缓存，即单例模式。
 *
 * Supplier<T> memoizeWithExpiration(Supplier<T> delegate, long duration, TimeUnit unit)
 * 功能与memoize相同，但是缓存的结果具有时效性。
 */
public class SupplierDemo {

    @Test
    public void test(){
        ComposedPredicateSupplier composedPredicateSupplier=new ComposedPredicateSupplier();
        Predicate<String> predicate=composedPredicateSupplier.get();
        boolean isNy=predicate.apply("NY");
        System.out.println(isNy);

        Predicate<String> predicate1=composedPredicateSupplier.get();
        System.out.println(predicate==predicate1);

        Supplier<Predicate<String>> wrapped= Suppliers.memoize(composedPredicateSupplier);
        Predicate<String> predicate2=wrapped.get();
        Predicate<String> predicate3=wrapped.get();
        System.out.println(predicate2==predicate3);

        Supplier<Predicate<String>> exWrapped=Suppliers.memoizeWithExpiration(composedPredicateSupplier,4, TimeUnit.SECONDS);

        Predicate<String> old=exWrapped.get();

        try {
            for (int i=0; i<10; i++) {
                System.out.println(i+":"+(exWrapped.get() == old));
                Thread.sleep(1000);
            }
        }catch (Exception e){

        }
    }
}

